package com.exchange.util;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.date.DatePattern;
import cn.hutool.core.date.DateTime;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.map.MapUtil;
import cn.hutool.core.util.NumberUtil;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import java.math.BigDecimal;
import java.sql.Time;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import javax.servlet.http.HttpServletRequest;

import com.exchange.common.model.MarketConfig;

/**
 * 业务方法工具类
 *
 * @author ml
 * @version 1.0
 * @create 2019-07-17 10:38 AM
 **/
public class BizUtils {


    /**
     * 获取对应Symbol
     * 买入时需要获取交易对中的后者
     * @param value 当前交易对
     * @return
     */
    public static String market(Object value) {
        if( ObjectUtil.isEmpty( value)){
            return null;
        }
        List<String> mks = StrUtil.splitTrim(StrUtil.toString(value), StrUtil.UNDERLINE);

        if( mks.size() > 1) {
            return mks.get( 1);
        }
        return StrUtil.toString( value);
    }

    /**
     *获取对应Symbol
     *买出时需要获取交易对中的前者
     * @param value 当前交易对
     * @return
     */
    public static String token(Object value) {
        if( ObjectUtil.isEmpty( value)){
            return null;
        }
        List<String> mks = StrUtil.splitTrim( StrUtil.toString(value), StrUtil.UNDERLINE);
        if( mks.size() > 1) {
            return mks.get( 0);
        }
        return StrUtil.toString( value);
    }
    
  

    /**
     * 授权过期时间
     * @return
     */
    public static final Long getAuthExpires(){
        DateTime endOfDay = DateUtil.endOfDay( DateUtil.date());
        return endOfDay.getTime() / 1000;
    }

    /**
     * 转换为 时间戳
     * @param object
     * @return
     */
    public static Long timestamp(Object object) {
        if ( ObjectUtil.isEmpty( object)) {
            return DateUtil.currentSeconds();
        }
        if (object instanceof Date) {
            return ((Date) object).getTime() / 1000;
        }
        // 格式化时间
        Date date = DateUtil.parse( StrUtil.toString( object), DatePattern.NORM_DATETIME_PATTERN);
        return date.getTime() / 1000;
    }
    
    /**
     * 交易对是否开盘
     * @param entity
     * @return
     */
    public static Boolean isOpen(MarketConfig entity) throws ParseException {
        Date current = new Date();
        if ( current.after( entity.getCreateTime())) {
            // 当前时间
            Long c = timeHms( StrUtil.EMPTY);
            String[] openDatas = StrUtil.split(entity.getOpenMarket(),StrUtil.COMMA);
            for (int i = 0; i < openDatas.length; i++) {
                String dar = openDatas[i];
                // 验证 日 开盘时间
                List<String> times = Arrays.asList(StrUtil.split(dar, StrUtil.DASHED));
                // 开
                Long dayOpen = timeHms(times.get(0));
                // 关
                Long dayClose = timeHms(times.get(1));
                if (c >= dayOpen && c <= dayClose) {
                    return Boolean.TRUE;
                }
            }
        }
        return Boolean.FALSE;
    }
    
    /**
     * 时间
     * @param date
     * @return
     */
    public static final Long timeHms(String date){
        SimpleDateFormat format = new SimpleDateFormat(DatePattern.NORM_TIME_PATTERN);
        Date dt = null;
        try {
            dt = format.parse(date);
        } catch (ParseException e) {
            try {
                Time time = new Time(System.currentTimeMillis());
                dt = format.parse(time.toString());
            } catch (ParseException e1) {
                return 1L;
            }
        }
        return dt.getTime() / 1000;
    }
    
    /**
     * 验证钱包余额
     * @param entity
     * @param amount
     */
//    public static final void verifyWallet(UserWalletEntity entity, BigDecimal amount,String field){
//        if ( ObjectUtil.isEmpty( entity)) {
//            // 余额不不足
//            throw ExUtils.error( LocaleKey.WALLET_INSUFFICIENT_FUNDS);
//        }
//        //可用余额
//        BigDecimal usable = BigDecimal.ZERO;
//        //根据传的字段计算对应的钱包余额
//        switch (field){
//            // 法币账户
//            case BizConst.WalletConst.WALLET_TYPE_OTC :
//                usable = NumberUtil.sub( entity.getBalanceOtc(), entity.getFrozenOtc());
//                break;
//            //币币账户
//            default:
//                usable = NumberUtil.sub( entity.getBalance(), entity.getFrozenBalance());
//                break;
//        }
//        if ( usable.compareTo( amount) < 0) {
//            throw ExUtils.error( LocaleKey.WALLET_INSUFFICIENT_FUNDS);
//        }
//    }

    /**
     * 手续费
     * @param num
     * @param symbol
     * @param param
     * @return
     */
//    public static final BigDecimal rate(BigDecimal num,String symbol, String param){
//        if(ObjectUtil.isEmpty( num)){
//            throw ExUtils.error( LocaleKey.SYS_PARAM_ERROR);
//        }
//        BigDecimal rate = BigDecimal.ZERO;
//        //执行到这里rate是0
//        //获取手续费配置信息(货币)
//        Map<String,Object> advert =  JSON.parseObject( param, new TypeReference<Map<String, Object>>(){});
//        if(MapUtil.isNotEmpty( advert)){
//            if(advert.containsKey( symbol)){   //执行玩else if 这里 rate是0E-8
//                rate = NumberUtil.mul(num,NumberUtil.toBigDecimal(StrUtil.toString(advert.get(symbol))));
//            }else{
//                rate = NumberUtil.mul( num, NumberUtil.toBigDecimal(StrUtil.toString(advert.get(BizConst.DEFAULT_RATE))));
//            }
//        }
        //活动手续费的配置信息
//        Map<String,Object> activity =  JSON.parseObject( param.get( BizConst.ParamsConst.ACTIVITY_FEE),
//                                                                new TypeReference<Map<String, Object>>(){});
//        if(MapUtil.isNotEmpty( activity)){
//            if( activity.containsKey( symbol)){
//                rate = BigDecimalUtils.multi( rate, NumberUtil.toBigDecimal(StrUtil.toString(activity.get(symbol))));
//            }else{
//                rate = BigDecimalUtils.multi( rate, NumberUtil.toBigDecimal(StrUtil.toString(activity.get(BizConst.DEFAULT_RATE))));
//            }
//        }
//        //个人手续费的配置信息
//        Map<String,Object> personal =  JSON.parseObject( param.get( BizConst.ParamsConst.PERSONAL_FEE),
//                                                                new TypeReference<Map<String, Object>>(){});
//        if(MapUtil.isNotEmpty( personal)){
//            if( activity.containsKey( symbol)){
//                rate = BigDecimalUtils.multi( rate, NumberUtil.toBigDecimal(StrUtil.toString(personal.get(symbol))));
//            }else{
//                rate = BigDecimalUtils.multi( rate, NumberUtil.toBigDecimal(StrUtil.toString(personal.get(BizConst.DEFAULT_RATE))));
//            }
//        }
//        return rate;
//    }

    /**
     * 移除对应的奖项
     * @param value
     * @param values
     */
    public static void removePrize(List<Integer> value,Integer... values) {
        //遍历移除的多个数据
        for(Integer num : values){
            value.remove( num);
        }
    }

    /**
     * 允许转入
     * @param entity
     * @param number
     * @return
     */
//    public static final void allowIn(CoinEntity entity, BigDecimal number){
//        if ( !StrUtil.equals( entity.getAllowIn(), AppConst.FIELD_Y)) {
//            throw ExUtils.error( LocaleKey.SYS_PARAM_ERROR);
//        }
//        //
//        if ( number.compareTo( entity.getLowerLimitIn()) < 0 ) {
//            throw ExUtils.error( LocaleKey.SYS_PARAM_ERROR);
//        }
//    }

    /**
     * 是否支持划转
     * @param dto
     * @param coin
     * @param wallet
     * @return
     */
//    public static final void allowTransfer(TransferDTO dto, CoinEntity coin, UserWalletEntity wallet){
        //判断划转目的账户类型
//        switch (dto.getAccountTo()){
//            //  法币账户
//            case BizConst.WalletConst.WALLET_TYPE_OTC :
//                if(!StrUtil.equals( AppConst.FIELD_Y, coin.getIsOtc())){
//                    throw ExUtils.error( LocaleKey.TRANSFER_TO_WALLET_ERROR);
//                }
//                break;
//            //合约账户
//            case BizConst.WalletConst.WALLET_TYPE_T :
//                if(!StrUtil.equals( AppConst.FIELD_Y, coin.getIsT())){
//                    throw ExUtils.error( LocaleKey.TRANSFER_TO_WALLET_ERROR);
//                }
//                break;
//        }
        //判断用户钱包余额是否足够
        //可用余额
//        BigDecimal usable = BigDecimal.ZERO;
//        switch ( dto.getAccountFrom()){
//            //法币账户
//            case BizConst.WalletConst.WALLET_TYPE_OTC :
//                usable = NumberUtil.sub( wallet.getBalanceOtc(), wallet.getFrozenOtc());
//                break;
//            //币币账户
//            case BizConst.WalletConst.WALLET_TYPE_TRADE :
//                usable = NumberUtil.sub( wallet.getBalance(), wallet.getFrozenBalance());
//                break;
//        }
//        //划转金额大于可用余额
//        if( NumberUtil.isGreater(dto.getAmount(), usable)){
//            throw ExUtils.error( LocaleKey.WALLET_INSUFFICIENT_FUNDS); // 余额不不足
//        }
//    }

    
    
    /**
     * 申请锁仓数量是否正确
     * @param configLockNum
     * @param lockNum
     * @return
     */
    public static final Boolean okLockNum(String configLockNum,BigDecimal lockNum){
    	
    	boolean okLockNum = false;
    	
    	String[] LockNums = configLockNum.split(",");
    	for(String LockNum : LockNums) {
    		BigDecimal bd = new BigDecimal(LockNum);
    		if(bd.compareTo(lockNum) == 0) {
    			okLockNum = true;
    		}
    	}
    	
    	return okLockNum;
        
    }


}
